package cool.mylog.mylog2end.utils;

import jakarta.annotation.PostConstruct;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
import java.util.Random;

/**
 * AES 对称加密
 * ECB 是最简单的加密方式，速度最快，但由于安全性差不建议使用
 * CBC 因为每个明文块都要与前一个密文块进行异或操作，比 ECB 要慢一些，
 * CFB 因为需要反复加密和解密，速度可能会更慢。
 */
@Component
public class Encryptor {
    /** 加密模式之 ECB，算法/模式/补码方式，加密出来有/字符 */
    public static final String AES_ECB = "AES/ECB/PKCS5Padding";

    /** 加密模式之 CBC，算法/模式/补码方式 */
    public static final String AES_CBC = "AES/CBC/PKCS5Padding";

    /** 加密模式之 CFB，算法/模式/补码方式 */
    public static final String AES_CFB = "AES/CFB/PKCS5Padding";

    /** AES 中的 IV 必须是 16 字节（128位）长 */
    private static final Integer IV_LENGTH = 16;

    /** 从配置文件获取key */
    @Value("${encryptor.key}")
    private String key;

    /**
     * 向量（IV），它是一个随机生成的字节数组，用于增加加密和解密的安全性
     */
    private static String IV;

    /**
     * AES 密钥规范
     */
    private static SecretKeySpec secretKeySpec;

    /**
     * AES加密器
     */
    private static Cipher cipher;

    @PostConstruct
    public void postConstruct() {
        // 初始化向量（IV）
        String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        Random random = new Random();
        StringBuilder sb = new StringBuilder();
        for(int i = 0 ; i < IV_LENGTH ; i++){
            int number = random.nextInt(str.length());
            sb.append(str.charAt(number));
        }
        // 创建AES加密器
        try {
            cipher = Cipher.getInstance(AES_ECB);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        IV = sb.toString();
        // 获取一个 AES 密钥规范
        secretKeySpec = new SecretKeySpec(getBytes(key), "AES");
    }

    /***
     * 空校验
     * @param str 需要判断的值
     */
    private static boolean isEmpty(Object str) {
        return null == str || "".equals(str);
    }

    /***
     * String 转 byte
     * @param str 需要转换的字符串
     */
    private static byte[] getBytes(String str){
        return str.getBytes(StandardCharsets.UTF_8);
    }

    /**
     * 加密 - 模式 ECB
     * @param text 需要加密的文本内容
     * */
    public static String encrypt(String text){
        if (isEmpty(text)) return null;
        try {
            cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);
            // 加密字节数组
            byte[] encryptedBytes = cipher.doFinal(getBytes(text));
            // 将密文转换为 Base64 编码字符串
            return Base64.getEncoder().encodeToString(encryptedBytes);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 解密 - 模式 ECB
     * @param text 需要解密的文本内容
     * */
    public static String decrypt(String text){
        if (isEmpty(text)) return null;

        // 将密文转换为16字节的字节数组
        byte[] textBytes = Base64.getDecoder().decode(text);

        try {
            cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);
            // 解密字节数组
            byte[] decryptedBytes = cipher.doFinal(textBytes);
            // 将明文转换为字符串
            return new String(decryptedBytes, StandardCharsets.UTF_8);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 加密 - 自定义加密模式
     * @param text 需要加密的文本内容
     * @param mode 加密模式
     * */
    public static String encrypt(String text, String mode){
        if (isEmpty(text)) return null;

        try {
            // 创建AES加密器
            Cipher cipher = Cipher.getInstance(mode);
            cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec, new IvParameterSpec(getBytes(IV)));
            // 加密字节数组
            byte[] encryptedBytes = cipher.doFinal(getBytes(text));
            // 将密文转换为 Base64 编码字符串
            return Base64.getEncoder().encodeToString(encryptedBytes);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 解密 - 自定义加密模式
     * @param text 需要解密的文本内容
     * @param mode 加密模式
     * */
    public static String decrypt(String text, String mode){
        if (isEmpty(text)) return null;

        // 将密文转换为16字节的字节数组
        byte[] textBytes = Base64.getDecoder().decode(text);

        try {
            // 创建AES加密器
            Cipher cipher = Cipher.getInstance(mode);
            cipher.init(Cipher.DECRYPT_MODE, secretKeySpec, new IvParameterSpec(getBytes(IV)));
            // 解密字节数组
            byte[] decryptedBytes = cipher.doFinal(textBytes);
            // 将明文转换为字符串
            return new String(decryptedBytes, StandardCharsets.UTF_8);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}
